package algorithm_primary.studyClass.新手课程.实现可插头尾队列;

import java.time.temporal.ValueRange;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * @author 衡孟浩
 * @date 2023/5/28 15:57
 */
public class DqQueue<V> {

    private DqNode<V> head;
    private DqNode<V> tail;

    private Integer size;

    public DqQueue() {
        head = null;
        tail = null;
        size = 0;
    }



    public int size() {
        return size;
    }


    public boolean isEmpty() {
        return size == 0;
    }


    /**
     * 添加节点到头部   也就是原本是这样的    node1   node2  现在添加一个  node到头部变为   node  node1   node2
     *
     * @param value
     * @return
     */
    public boolean pushHead(V value) {
        DqNode<V> newNode = new DqNode<>(value);
        // 如果head为null说明 此时这个队列是空的  那么把这个新的值同时赋值给   head 和 tail
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            // 说明有元素   那么把老的头指向新的头节点   并且使 老的头节点的   last指向这个新的节点   新的节点的 next指向 老的头节点
            newNode.next = head;
            head.last = newNode;
            head = newNode;
        }
        size++;
        return true;
    }


    /**
     * 添加节点到尾部   也就是原本是这样的    node1   node2  现在添加一个  node到尾部变为     node1   node2  node
     *
     * @param value
     * @return
     */
    public boolean pushTail(V value) {
        DqNode<V> oldNode = new DqNode<>(value);
        // 如果head为null说明 此时这个队列是空的  那么把这个新的值同时赋值给   head 和 tail
        if (head == null) {
            head = oldNode;
            tail = oldNode;
        } else {
            // 说明有元素   那么把老的尾指向新的尾节点   并且使 老的尾节点的   next指向这个新的节点   新的节点的 last指向 老的尾节点
            oldNode.last = tail;
            tail.next = oldNode;
            tail = oldNode;
        }
        size++;
        return true;
    }


    /**
     * 弹出尾巴接节点并且返回值
     *
     * @return
     */
    public V pollTail() {
        // 如果head为null说明 此时这个队列是空的  那么把这个新的值同时赋值给   head 和 tail
        V resultValue = null;
        if (tail == null) {
            return resultValue;
        }
        if (head == tail) {
            resultValue = tail.value;
            head = null;
            tail = null;
            size--;
        } else {
            // 表示还有很多个元素  最起码大于等于2个
            resultValue = tail.value;
            tail = tail.last;
            size--;
        }
        return resultValue;

    }


    /**
     * 弹出尾巴接节点并且返回值
     *
     * @return
     */
    public V pollHead() {
        // 如果head为null说明 此时这个队列是空的  那么把这个新的值同时赋值给   head 和 tail
        V resultValue = null;
        if (head == null) {
            return resultValue;
        }
        if (head == tail) {
            resultValue = head.value;
            head = null;
            tail = null;
            size--;
        } else {
            // 表示还有很多个元素  最起码大于等于2个
            resultValue = head.value;
            head = head.next;
            size--;
        }
        return resultValue;

    }


    public boolean contains(Object o) {
        return false;
    }


    public Iterator iterator() {
        return null;
    }


    public Object[] toArray() {
        return new Object[0];
    }


    public boolean add(Object o) {
        return false;
    }


    public boolean remove(Object o) {
        return false;
    }


    public boolean addAll(Collection c) {
        return false;
    }


    public boolean addAll(int index, Collection c) {
        return false;
    }


    public void clear() {

    }


    public Object get(int index) {
        return null;
    }


    public Object set(int index, Object element) {
        return null;
    }


    public void add(int index, Object element) {

    }


    public Object remove(int index) {
        return null;
    }


    public int indexOf(Object o) {
        return 0;
    }


    public int lastIndexOf(Object o) {
        return 0;
    }


    public ListIterator listIterator() {
        return null;
    }


    public ListIterator listIterator(int index) {
        return null;
    }


    public List subList(int fromIndex, int toIndex) {
        return null;
    }


    public boolean retainAll(Collection c) {
        return false;
    }


    public boolean removeAll(Collection c) {
        return false;
    }


    public boolean containsAll(Collection c) {
        return false;
    }


    public Object[] toArray(Object[] a) {
        return new Object[0];
    }
}
